package com.jeesite.modules.service;

import com.jeesite.common.service.BaseService;
import com.jeesite.modules.dao.PaymentOrderDao;
import com.jeesite.modules.entity.PaymentOrder;
import com.jeesite.modules.dto.PaymentOrderDto;
import com.jeesite.modules.utils.AlipayUtil;
import com.jeesite.modules.utils.WechatPayUtil;
import com.jeesite.modules.utils.UnionpayUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.Map;

/**
 * 支付服务类 - 真实SDK实现
 * @author LaVenderGong
 * @version 2025-08-16
 */
@Service
@Transactional(readOnly = true)
public class PaymentService extends BaseService {

    @Autowired
    private PaymentOrderDao paymentOrderDao;

    @Autowired
    private AlipayUtil alipayUtil;

    @Autowired
    private WechatPayUtil wechatPayUtil;

    @Autowired
    private UnionpayUtil unionpayUtil;

    @Autowired
    private DonationService donationService;

    /**
     * 创建支付宝支付订单
     * @param order 支付订单对象
     * @return 支付结果，包含支付页面HTML或链接
     */
    @Transactional(readOnly = false)
    public Map<String, Object> createAlipayOrder(PaymentOrder order) {
        Map<String, Object> result = new HashMap<>();
        
        try {
            // 检查支付宝配置
            if (!alipayUtil.checkConfig()) {
                result.put("success", false);
                result.put("message", "支付宝配置不完整，请检查配置文件");
                return result;
            }
            
            // 更新订单状态为支付中
            paymentOrderDao.updatePaymentOrderStatus(
                order.getOrderId(),
                PaymentOrder.STATUS_PAYING,
                null,
                null,
                null
            );
            
            // 调用支付宝工具类创建支付
            Map<String, Object> payResult = alipayUtil.createPayment(
                order.getOrderId(),                    // 订单号
                order.getAmount().toString(),          // 支付金额（元）
                "KBB服务器捐赠支持"                     // 商品标题
            );
            
            if ((Boolean) payResult.get("success")) {
                // 支付宝订单创建成功
                result.put("success", true);
                result.put("payUrl", payResult.get("payUrl"));     // 支付页面HTML
                result.put("orderId", order.getOrderId());
                result.put("message", "支付宝订单创建成功");
                
                logger.info("支付宝订单创建成功，订单号: {}", order.getOrderId());
            } else {
                // 支付宝订单创建失败
                result.put("success", false);
                result.put("message", payResult.get("message"));
                
                // 更新订单状态为失败
                paymentOrderDao.updatePaymentOrderStatus(
                    order.getOrderId(),
                    PaymentOrder.STATUS_FAILED,
                    null,
                    null,
                    null
                );
                
                logger.error("支付宝订单创建失败，订单号: {}, 原因: {}", 
                    order.getOrderId(), payResult.get("message"));
            }
            
        } catch (Exception e) {
            logger.error("创建支付宝订单异常，订单号: " + order.getOrderId(), e);
            result.put("success", false);
            result.put("message", "创建支付宝订单失败: " + e.getMessage());
            
            // 更新订单状态为失败
            try {
                paymentOrderDao.updatePaymentOrderStatus(
                    order.getOrderId(),
                    PaymentOrder.STATUS_FAILED,
                    null,
                    null,
                    null
                );
            } catch (Exception updateException) {
                logger.error("更新订单状态失败", updateException);
            }
        }
        
        return result;
    }

    /**
     * 创建支付宝预创建订单（扫码支付）
     * @param order 支付订单对象
     * @return 支付结果，包含二维码链接
     */
    @Transactional(readOnly = false)
    public Map<String, Object> createAlipayPrecreateOrder(PaymentOrder order) {
        Map<String, Object> result = new HashMap<>();

        try {
            // 检查支付宝配置
            if (!alipayUtil.checkConfig()) {
                result.put("success", false);
                result.put("message", "支付宝配置不完整，请检查配置文件");
                return result;
            }

            // 更新订单状态为支付中
            paymentOrderDao.updatePaymentOrderStatus(
                order.getOrderId(),
                PaymentOrder.STATUS_PAYING,
                null,
                null,
                null
            );

            // 调用支付宝工具类创建预创建支付（扫码支付）
            Map<String, Object> payResult = alipayUtil.createPrecreatePayment(
                order.getOrderId(),                    // 订单号
                order.getAmount().toString(),          // 支付金额（元）
                "KBB服务器捐赠支持"                     // 商品标题
            );

            if ((Boolean) payResult.get("success")) {
                // 支付宝预创建订单成功
                result.put("success", true);
                result.put("qrCode", payResult.get("qrCode"));         // 二维码链接
                result.put("orderId", order.getOrderId());
                result.put("message", "支付宝预创建订单成功");

                logger.info("支付宝预创建订单成功，订单号: {}", order.getOrderId());
            } else {
                // 支付宝预创建订单失败
                result.put("success", false);
                result.put("message", payResult.get("message"));

                // 更新订单状态为失败
                paymentOrderDao.updatePaymentOrderStatus(
                    order.getOrderId(),
                    PaymentOrder.STATUS_FAILED,
                    null,
                    null,
                    null
                );

                logger.error("支付宝预创建订单失败，订单号: {}, 原因: {}",
                    order.getOrderId(), payResult.get("message"));
            }

        } catch (Exception e) {
            logger.error("创建支付宝预创建订单异常，订单号: " + order.getOrderId(), e);
            result.put("success", false);
            result.put("message", "创建支付宝预创建订单失败: " + e.getMessage());

            // 更新订单状态为失败
            try {
                paymentOrderDao.updatePaymentOrderStatus(
                    order.getOrderId(),
                    PaymentOrder.STATUS_FAILED,
                    null,
                    null,
                    null
                );
            } catch (Exception updateException) {
                logger.error("更新订单状态失败", updateException);
            }
        }

        return result;
    }

    /**
     * 创建微信支付订单
     * @param order 支付订单对象
     * @return 支付结果，包含二维码链接
     */
    @Transactional(readOnly = false)
    public Map<String, Object> createWechatOrder(PaymentOrder order) {
        Map<String, Object> result = new HashMap<>();
        
        try {
            // 检查微信支付配置
            if (!wechatPayUtil.checkConfig()) {
                result.put("success", false);
                result.put("message", "微信支付配置不完整，请检查配置文件");
                return result;
            }
            
            // 更新订单状态为支付中
            paymentOrderDao.updatePaymentOrderStatus(
                order.getOrderId(),
                PaymentOrder.STATUS_PAYING,
                null,
                null,
                null
            );
            
            // 调用微信支付工具类创建支付
            Map<String, Object> payResult = wechatPayUtil.createPayment(
                order.getOrderId(),                    // 订单号
                order.getAmount().toString(),          // 支付金额（元）
                "KBB服务器捐赠支持"                     // 商品描述
            );
            
            if ((Boolean) payResult.get("success")) {
                // 微信支付订单创建成功
                result.put("success", true);
                result.put("codeUrl", payResult.get("codeUrl"));   // 二维码链接
                result.put("orderId", order.getOrderId());
                result.put("message", "微信支付订单创建成功");
                
                logger.info("微信支付订单创建成功，订单号: {}", order.getOrderId());
            } else {
                // 微信支付订单创建失败
                result.put("success", false);
                result.put("message", payResult.get("message"));
                
                // 更新订单状态为失败
                paymentOrderDao.updatePaymentOrderStatus(
                    order.getOrderId(),
                    PaymentOrder.STATUS_FAILED,
                    null,
                    null,
                    null
                );
                
                logger.error("微信支付订单创建失败，订单号: {}, 原因: {}", 
                    order.getOrderId(), payResult.get("message"));
            }
            
        } catch (Exception e) {
            logger.error("创建微信支付订单异常，订单号: " + order.getOrderId(), e);
            result.put("success", false);
            result.put("message", "创建微信支付订单失败: " + e.getMessage());
            
            // 更新订单状态为失败
            try {
                paymentOrderDao.updatePaymentOrderStatus(
                    order.getOrderId(),
                    PaymentOrder.STATUS_FAILED,
                    null,
                    null,
                    null
                );
            } catch (Exception updateException) {
                logger.error("更新订单状态失败", updateException);
            }
        }
        
        return result;
    }

    /**
     * 创建云闪付支付订单
     * @param order 支付订单对象
     * @return 支付结果，包含支付表单HTML
     */
    @Transactional(readOnly = false)
    public Map<String, Object> createUnionpayOrder(PaymentOrder order) {
        Map<String, Object> result = new HashMap<>();

        try {
            // 检查云闪付配置
            if (!unionpayUtil.checkConfig()) {
                result.put("success", false);
                result.put("message", "云闪付配置不完整，请检查配置文件");
                return result;
            }

            // 更新订单状态为支付中
            paymentOrderDao.updatePaymentOrderStatus(
                order.getOrderId(),
                PaymentOrder.STATUS_PAYING,
                null,
                null,
                null
            );

            // 调用云闪付工具类创建支付
            Map<String, Object> payResult = unionpayUtil.createPayment(
                order.getOrderId(),                    // 订单号
                order.getAmount().toString(),          // 支付金额（人民币）
                "KBB服务器捐赠支持"                     // 商品描述
            );
            
            if ((Boolean) payResult.get("success")) {
                // 云闪付订单创建成功
                result.put("success", true);
                result.put("formHtml", payResult.get("formHtml"));       // 支付表单HTML
                result.put("orderId", order.getOrderId());
                result.put("paymentType", payResult.get("paymentType")); // 支付类型
                result.put("message", "云闪付订单创建成功");

                logger.info("云闪付订单创建成功，订单号: {}", order.getOrderId());
            } else {
                // 云闪付订单创建失败
                result.put("success", false);
                result.put("message", payResult.get("message"));

                // 更新订单状态为失败
                paymentOrderDao.updatePaymentOrderStatus(
                    order.getOrderId(),
                    PaymentOrder.STATUS_FAILED,
                    null,
                    null,
                    null
                );

                logger.error("云闪付订单创建失败，订单号: {}, 原因: {}",
                    order.getOrderId(), payResult.get("message"));
            }
            
        } catch (Exception e) {
            logger.error("创建云闪付订单异常，订单号: " + order.getOrderId(), e);
            result.put("success", false);
            result.put("message", "创建云闪付订单失败: " + e.getMessage());
            
            // 更新订单状态为失败
            try {
                paymentOrderDao.updatePaymentOrderStatus(
                    order.getOrderId(),
                    PaymentOrder.STATUS_FAILED,
                    null,
                    null,
                    null
                );
            } catch (Exception updateException) {
                logger.error("更新订单状态失败", updateException);
            }
        }
        
        return result;
    }

    /**
     * 验证支付宝回调签名
     * @param params 回调参数Map
     * @return 验证结果，true表示验证通过
     */
    public boolean verifyAlipayCallback(Map<String, String> params) {
        try {
            // 使用支付宝工具类验证签名
            boolean isValid = alipayUtil.verifyCallback(params);
            
            if (isValid) {
                logger.info("支付宝回调签名验证成功，订单号: {}", params.get("out_trade_no"));
            } else {
                logger.warn("支付宝回调签名验证失败，订单号: {}", params.get("out_trade_no"));
            }
            
            return isValid;
            
        } catch (Exception e) {
            logger.error("支付宝回调签名验证异常", e);
            return false;
        }
    }

    /**
     * 验证微信支付回调签名
     * @param requestId 请求ID
     * @param timestamp 时间戳
     * @param nonce 随机字符串
     * @param body 请求体
     * @param signature 签名
     * @return 验证结果，true表示验证通过
     */
    public boolean verifyWechatCallback(String requestId, String timestamp, String nonce, String body, String signature) {
        try {
            // 使用微信支付工具类验证签名
            boolean isValid = wechatPayUtil.verifyCallback(requestId, timestamp, nonce, body, signature);
            
            if (isValid) {
                logger.info("微信支付回调签名验证成功");
            } else {
                logger.warn("微信支付回调签名验证失败");
            }
            
            return isValid;
            
        } catch (Exception e) {
            logger.error("微信支付回调签名验证异常", e);
            return false;
        }
    }
    
    /**
     * 验证微信支付XML回调签名（兼容旧版本）
     * @param xmlData XML格式的回调数据
     * @return 验证结果
     */
    public boolean verifyWechatCallbackXml(String xmlData) {
        try {
            // 使用微信支付工具类验证XML签名
            boolean isValid = wechatPayUtil.verifyCallbackXml(xmlData);
            
            if (isValid) {
                logger.info("微信支付XML回调签名验证成功");
            } else {
                logger.warn("微信支付XML回调签名验证失败");
            }
            
            return isValid;
            
        } catch (Exception e) {
            logger.error("微信支付XML回调签名验证异常", e);
            return false;
        }
    }

    /**
     * 验证云闪付回调
     * @param params 回调参数
     * @return 验证结果
     */
    public boolean verifyUnionpayCallback(Map<String, String> params) {
        try {
            // 使用云闪付工具类验证回调
            boolean isValid = unionpayUtil.verifyCallback(params);

            if (isValid) {
                logger.info("云闪付回调验证成功，订单ID: {}", params.get("orderId"));
            } else {
                logger.warn("云闪付回调验证失败，订单ID: {}", params.get("orderId"));
            }

            return isValid;

        } catch (Exception e) {
            logger.error("云闪付回调验证异常", e);
            return false;
        }
    }

    /**
     * 查询支付订单状态（使用DTO避免StackOverflowError）
     * @param orderId 订单号
     * @return 支付订单DTO对象
     */
    public PaymentOrderDto getPaymentOrderDto(String orderId) {
        try {
            return paymentOrderDao.findByOrderIdDto(orderId);
        } catch (Exception e) {
            logger.error("查询支付订单失败，订单号: " + orderId, e);
            return null;
        }
    }

    /**
     * 查询支付订单原始数据（用于测试和调试）
     * @param orderId 订单号
     * @return 支付订单原始数据
     */
    public Map<String, Object> getPaymentOrderData(String orderId) {
        try {
            return paymentOrderDao.findByOrderIdNative(orderId);
        } catch (Exception e) {
            logger.error("查询支付订单原始数据失败，订单号: " + orderId, e);
            return null;
        }
    }

    /**
     * 查询支付订单状态
     * @param orderId 订单号
     * @return 支付订单对象
     */
    public PaymentOrder getPaymentOrder(String orderId) {
        try {
            // 使用原生查询避免StackOverflowError
            Map<String, Object> orderData = paymentOrderDao.findByOrderIdNative(orderId);
            if (orderData == null) {
                return null;
            }

            // 手动构建PaymentOrder对象
            PaymentOrder order = new PaymentOrder();

            // 设置 DataEntity 的字段
            if (orderData.get("id") != null) {
                order.setId(orderData.get("id").toString());
            }
            order.setCreateBy((String) orderData.get("create_by"));
            order.setCreateDate((java.util.Date) orderData.get("create_date"));
            order.setUpdateBy((String) orderData.get("update_by"));
            order.setUpdateDate((java.util.Date) orderData.get("update_date"));
            order.setRemarks((String) orderData.get("remarks"));
            // 删除标记字段，DataEntity 中可能没有 setDelFlag 方法，先注释掉
            // order.setDelFlag((String) orderData.get("del_flag"));

            // 设置 PaymentOrder 的字段
            order.setOrderId((String) orderData.get("order_id"));
            order.setDonationId(orderData.get("donation_id") != null ?
                Long.valueOf(orderData.get("donation_id").toString()) : null);
            order.setPaymentMethod((String) orderData.get("payment_method"));
            order.setAmount(orderData.get("amount") != null ?
                new java.math.BigDecimal(orderData.get("amount").toString()) : null);
            order.setStatus((String) orderData.get("status"));
            order.setThirdPartyOrderId((String) orderData.get("third_party_order_id"));
            order.setCreateTime((java.util.Date) orderData.get("create_time"));
            order.setPayTime((java.util.Date) orderData.get("pay_time"));
            order.setCallbackData((String) orderData.get("callback_data"));

            return order;
        } catch (Exception e) {
            logger.error("查询支付订单失败，订单号: " + orderId, e);
            return null;
        }
    }

    /**
     * 查询第三方支付状态
     * @param orderId 订单号
     * @param paymentMethod 支付方式
     * @return 查询结果
     */
    public Map<String, Object> queryThirdPartyPaymentStatus(String orderId, String paymentMethod) {
        Map<String, Object> result = new HashMap<>();

        try {
            PaymentOrder order = getPaymentOrder(orderId);
            if (order == null) {
                result.put("success", false);
                result.put("message", "订单不存在");
                return result;
            }

            // 如果订单已经是成功或失败状态，直接返回本地状态
            if (PaymentOrder.STATUS_SUCCESS.equals(order.getStatus()) ||
                PaymentOrder.STATUS_FAILED.equals(order.getStatus()) ||
                PaymentOrder.STATUS_CANCELLED.equals(order.getStatus())) {
                result.put("success", true);
                result.put("localOrderId", orderId);
                result.put("localStatus", order.getStatus());
                result.put("message", "订单状态: " + order.getStatus());
                return result;
            }

            // 对于处理中的订单，查询第三方支付状态
            Map<String, Object> queryResult;
            switch (paymentMethod.toLowerCase()) {
                case "alipay":
                    queryResult = alipayUtil.queryOrderStatus(orderId);
                    break;
                case "wechat":
                    queryResult = wechatPayUtil.queryOrderStatus(orderId);
                    break;
                case "unionpay":
                    queryResult = unionpayUtil.queryOrderStatus(orderId);
                    break;
                default:
                    queryResult = new HashMap<>();
                    queryResult.put("success", false);
                    queryResult.put("message", "不支持的支付方式: " + paymentMethod);
            }

            // 处理查询结果
            if (queryResult.containsKey("success") && !(Boolean) queryResult.get("success")) {
                // 第三方查询失败，但这可能是正常的（订单还未支付）
                result.put("success", true);
                result.put("localOrderId", orderId);
                result.put("localStatus", order.getStatus());
                result.put("message", "订单等待支付中");
                result.put("thirdPartyMessage", queryResult.get("message"));
            } else {
                // 合并查询结果
                result.putAll(queryResult);
                result.put("localOrderId", orderId);
                result.put("localStatus", order.getStatus());
            }

        } catch (Exception e) {
            logger.error("查询第三方支付状态失败，订单号: " + orderId, e);
            result.put("success", false);
            result.put("message", "查询支付状态失败: " + e.getMessage());
        }

        return result;
    }

    /**
     * 取消支付订单
     * @param orderId 订单号
     * @return 取消结果
     */
    @Transactional
    public Map<String, Object> cancelPayment(String orderId) {
        Map<String, Object> result = new HashMap<>();

        try {
            PaymentOrderDto order = getPaymentOrderDto(orderId);
            if (order == null) {
                result.put("success", false);
                result.put("message", "订单不存在");
                return result;
            }

            // 检查订单状态是否可以取消
            if (PaymentOrderDto.STATUS_SUCCESS.equals(order.getStatus())) {
                result.put("success", false);
                result.put("message", "订单已支付成功，无法取消");
                return result;
            }

            if (PaymentOrderDto.STATUS_CANCELLED.equals(order.getStatus())) {
                result.put("success", false);
                result.put("message", "订单已取消");
                return result;
            }

            // 更新订单状态为已取消
            paymentOrderDao.updatePaymentOrderStatus(
                orderId,
                PaymentOrderDto.STATUS_CANCELLED,
                null,
                null,
                null
            );

            result.put("success", true);
            result.put("message", "订单取消成功");
            result.put("orderId", orderId);

            logger.info("订单取消成功，订单号: {}", orderId);

        } catch (Exception e) {
            logger.error("取消支付订单失败，订单号: " + orderId, e);
            result.put("success", false);
            result.put("message", "取消失败: " + e.getMessage());
        }

        return result;
    }

    /**
     * 检查支付宝配置
     * @return 支付宝配置是否正确
     */
    public boolean checkAlipayConfig() {
        try {
            return alipayUtil.checkConfig();
        } catch (Exception e) {
            logger.error("检查支付宝配置失败", e);
            return false;
        }
    }

    /**
     * 直接创建支付宝预创建订单（不依赖数据库操作）
     * @param orderId 订单ID
     * @param amount 金额
     * @param subject 订单标题
     * @param body 订单描述
     * @return 支付结果
     */
    public Map<String, Object> createAlipayPrecreateOrderDirect(String orderId, java.math.BigDecimal amount, String subject, String body) {
        Map<String, Object> result = new HashMap<>();

        try {
            logger.info("开始创建支付宝预创建订单: orderId={}, amount={}", orderId, amount);

            // 直接调用支付宝工具类创建预创建订单
            Map<String, Object> alipayResult = alipayUtil.createPrecreatePayment(orderId, amount.toString(), subject);

            if (alipayResult != null && Boolean.TRUE.equals(alipayResult.get("success"))) {
                result.put("success", true);
                result.put("message", "支付宝预创建订单成功");
                result.put("data", alipayResult);
                logger.info("支付宝预创建订单成功: {}", orderId);
            } else {
                result.put("success", false);
                result.put("message", "支付宝预创建订单失败: " + (alipayResult != null ? alipayResult.get("message") : "未知错误"));
                logger.error("支付宝预创建订单失败: {}", alipayResult);
            }

        } catch (Exception e) {
            logger.error("创建支付宝预创建订单异常", e);
            result.put("success", false);
            result.put("message", "创建支付宝预创建订单异常: " + e.getMessage());
        }

        return result;
    }

    /**
     * 初始化数据库表
     * @return 初始化是否成功
     */
    @Transactional(readOnly = false)
    public boolean initDatabase() {
        try {
            // 先检查表是否存在
            PaymentOrder testOrder = new PaymentOrder();
            testOrder.setOrderId("TEST_ORDER_ID");
            testOrder.setPaymentMethod("test");
            testOrder.setAmount(new java.math.BigDecimal("0.01"));
            testOrder.setStatus("CREATED");
            testOrder.setCreateTime(new java.util.Date());

            // 尝试插入测试数据来验证表是否存在
            try {
                paymentOrderDao.insert(testOrder);
                // 如果插入成功，删除测试数据
                paymentOrderDao.delete(testOrder);
                logger.info("payment_orders表已存在");
                return true;
            } catch (Exception e) {
                logger.info("payment_orders表不存在，需要创建");
                // 表不存在，返回false，提示需要手动创建表
                return false;
            }
        } catch (Exception e) {
            logger.error("数据库表检查失败", e);
            return false;
        }
    }

    /**
     * 检查所有支付方式的配置状态
     * @return 配置状态Map
     */
    public Map<String, Boolean> checkAllPaymentConfigs() {
        Map<String, Boolean> configStatus = new HashMap<>();
        
        try {
            configStatus.put("alipay", alipayUtil.checkConfig());
            configStatus.put("wechat", wechatPayUtil.checkConfig());
            configStatus.put("unionpay", unionpayUtil.checkConfig());
        } catch (Exception e) {
            logger.error("检查支付配置失败", e);
            configStatus.put("alipay", false);
            configStatus.put("wechat", false);
            configStatus.put("unionpay", false);
        }
        
        return configStatus;
    }

    /**
     * 更新支付成功状态
     * @param orderId 订单号
     * @param thirdPartyOrderId 第三方订单号
     * @param callbackData 回调数据
     */
    @Transactional
    public void updatePaymentSuccess(String orderId, String thirdPartyOrderId, Map<String, String> callbackData) {
        try {
            // 更新支付订单状态
            paymentOrderDao.updatePaymentOrderStatus(
                orderId,
                PaymentOrderDto.STATUS_SUCCESS,
                new java.util.Date(),
                thirdPartyOrderId,
                callbackData != null ? callbackData.toString() : null
            );

            // 查询支付订单获取捐赠记录ID
            PaymentOrderDto paymentOrder = getPaymentOrderDto(orderId);
            if (paymentOrder != null && paymentOrder.getDonationId() != null) {
                // 更新捐赠记录的支付状态
                donationService.updatePaymentStatus(paymentOrder.getDonationId(), "PAID", orderId);
            }

            logger.info("支付成功状态更新完成: {}", orderId);
        } catch (Exception e) {
            logger.error("更新支付成功状态失败，订单号: " + orderId, e);
            throw e;
        }
    }

    /**
     * 更新支付关闭状态
     * @param orderId 订单号
     * @param thirdPartyOrderId 第三方订单号
     * @param callbackData 回调数据
     */
    @Transactional
    public void updatePaymentClosed(String orderId, String thirdPartyOrderId, Map<String, String> callbackData) {
        try {
            // 更新支付订单状态
            paymentOrderDao.updatePaymentOrderStatus(
                orderId,
                PaymentOrderDto.STATUS_FAILED,
                null,
                thirdPartyOrderId,
                callbackData != null ? callbackData.toString() : null
            );

            // 查询支付订单获取捐赠记录ID
            PaymentOrderDto paymentOrder = getPaymentOrderDto(orderId);
            if (paymentOrder != null && paymentOrder.getDonationId() != null) {
                // 更新捐赠记录的支付状态
                donationService.updatePaymentStatus(paymentOrder.getDonationId(), "FAILED", orderId);
            }

            logger.info("支付关闭状态更新完成: {}", orderId);
        } catch (Exception e) {
            logger.error("更新支付关闭状态失败，订单号: " + orderId, e);
            throw e;
        }
    }
}
